

<!DOCTYPE html>
<html lang="zh-CN" data-default-color-scheme=&#34;auto&#34;>



<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/img/2.jpg">
  <link rel="icon" type="image/png" href="/img/2.jpg">
  <meta name="viewport"
        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="description" content="">
  <meta name="author" content="K">
  <meta name="keywords" content="">
  <title>python类(class)-面向对象 - K</title>

  <link  rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/css/bootstrap.min.css" />


  <link  rel="stylesheet" href="https://cdn.staticfile.org/github-markdown-css/4.0.0/github-markdown.min.css" />
  <link  rel="stylesheet" href="/lib/hint/hint.min.css" />

  
    
    
      
      <link  rel="stylesheet" href="https://cdn.staticfile.org/highlight.js/10.0.0/styles/github-gist.min.css" />
    
  

  


<!-- 主题依赖的图标库，不要自行修改 -->

<link rel="stylesheet" href="//at.alicdn.com/t/font_1749284_ba1fz6golrf.css">



<link rel="stylesheet" href="//at.alicdn.com/t/font_1736178_kmeydafke9r.css">


<link  rel="stylesheet" href="/css/main.css" />

<!-- 自定义样式保持在最底部 -->


  <script  src="/js/utils.js" ></script>
  <script  src="/js/color-schema.js" ></script>
<meta name="generator" content="Hexo 5.2.0"></head>


<body>
  <header style="height: 70vh;">
    <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand"
       href="/">&nbsp;<strong>かい</strong>&nbsp;</a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/">
                <i class="iconfont icon-home-fill"></i>
                首页
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/archives/">
                <i class="iconfont icon-archive-fill"></i>
                归档
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/categories/">
                <i class="iconfont icon-category-fill"></i>
                分类
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/tags/">
                <i class="iconfont icon-tags-fill"></i>
                标签
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/about/">
                <i class="iconfont icon-user-fill"></i>
                关于
              </a>
            </li>
          
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" data-toggle="modal" data-target="#modalSearch">&nbsp;<i
                class="iconfont icon-search"></i>&nbsp;</a>
          </li>
        
        
          <li class="nav-item" id="color-toggle-btn">
            <a class="nav-link" href="javascript:">&nbsp;<i
                class="iconfont icon-dark" id="color-toggle-icon"></i>&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

    <div class="banner intro-2" id="background" parallax=true
         style="background: url('/img/1.jpg') no-repeat center center;
           background-size: cover;">
      <div class="full-bg-img">
        <div class="mask flex-center" style="background-color: rgba(0, 0, 0, 0.3)">
          <div class="container page-header text-center fade-in-up">
            <span class="h2" id="subtitle">
              
            </span>

            
              <div class="mt-3">
  
  
    <span class="post-meta">
      <i class="iconfont icon-date-fill" aria-hidden="true"></i>
      <time datetime="2020-08-23 07:32" pubdate>
        2020年8月23日 早上
      </time>
    </span>
  
</div>

<div class="mt-1">
  
    
    <span class="post-meta mr-2">
      <i class="iconfont icon-chart"></i>
      5.3k 字
    </span>
  

  
    
    <span class="post-meta mr-2">
      <i class="iconfont icon-clock-fill"></i>
      
      
      63
       分钟
    </span>
  

  
  
</div>

            
          </div>

          
        </div>
      </div>
    </div>
  </header>

  <main>
    
      

<div class="container-fluid">
  <div class="row">
    <div class="d-none d-lg-block col-lg-2"></div>
    <div class="col-lg-8 nopadding-md">
      <div class="container nopadding-md" id="board-ctn">
        <div class="py-5" id="board">
          <article class="post-content mx-auto" id="post">
            <!-- SEO header -->
            <h1 style="display: none">python类(class)-面向对象</h1>
            
            <div class="markdown-body" id="post-body">
              <h2 id="面型对象的三大特性"><a href="#面型对象的三大特性" class="headerlink" title="面型对象的三大特性"></a>面型对象的三大特性</h2><ul>
<li>封装<ul>
<li>确保对象中的数据安全</li>
</ul>
</li>
<li>继承<ul>
<li>保证了对象的可扩展性</li>
</ul>
</li>
<li>多态<ul>
<li>保证了程序的灵活性</li>
</ul>
</li>
</ul>
<h2 id="类的封装"><a href="#类的封装" class="headerlink" title="类的封装"></a>类的封装</h2><ul>
<li><p>封装是面向对象的三大特性之一</p>
</li>
<li><p>封装是指隐藏对象中一些不希望被外部所访问的属性或方法</p>
</li>
<li><p>如果要隐藏一个类型的属性</p>
<blockquote>
<p>将对象的属性名，修改为一个外部不知道的名字    （差不多就是自己骗自己这种感觉，外部还是能改的）</p>
</blockquote>
</li>
<li><p>如何获取（修改）对象中的属性</p>
<blockquote>
<p>需要提供一个getter和setter方法，使外部可以访问到属性<br>  getter 获取对象中指定的属性 （get_属性名）<br>  setter 用来设置对象的指定属性（set_属性名）</p>
</blockquote>
</li>
<li><p>使用封装确实增加了类的定义复杂程度，但是它也确保了数据的安全性<br> 1.隐藏了属性名，使调用者无法随意的修改对象中的属性<br> 2.增加了getter和setter的方法，很好的控制了属性是否是只读的<br> 3.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的的<br> 4.使用getter方法获取属性，使用stter方法设置属性可以在读取属性和修改属性的同时做一些其他的处理<br> 5.使用getter方法可以表示一些计算的属性，比如说在获取属性时，会自动输出一个属性，或者做一些运算等</p>
</li>
<li><p>如果希望属性是只读的，则可以直接去掉setter方法</p>
</li>
<li><p>如果希望属性不能被外部访问，则可以直接去掉getter方法</p>
<pre><code class="hljs ruby">例
<span class="hljs-comment"># 定义一个狗类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Dog</span>():</span>
    <span class="hljs-comment"># 定义初始化方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name,old,gen)</span></span><span class="hljs-symbol">:</span>
	  <span class="hljs-comment"># 在里面定义属性</span>
      <span class="hljs-keyword">self</span>.hidden_name = name
      <span class="hljs-keyword">self</span>.hidden_old = old
      <span class="hljs-keyword">self</span>.hidden_gen = gen

    <span class="hljs-comment"># 定义修改name属性的方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">set_name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.hidden_name = name

    <span class="hljs-comment"># 定义查看name属性的方法    </span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.hidden_name

    <span class="hljs-comment"># 定义修改old属性的方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">set_old</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,old)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-comment"># 年龄没有负数，所以这里要用一个判定如果对方修改的年龄小于0则不作任何操作</span>
        <span class="hljs-keyword">if</span> old &gt;= <span class="hljs-number">0</span> <span class="hljs-symbol">:</span>
            <span class="hljs-keyword">self</span>.hidden_old  = old   
    <span class="hljs-comment"># 定义查看old属性的方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_old</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.hidden_old
        
    <span class="hljs-comment"># 定义修改gen属性的方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">set_gen</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,gen)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.hidden_gen = gen
    <span class="hljs-comment"># 定义查看gen属性的方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_gen</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.hidden_gen

    <span class="hljs-comment"># 定义的通用方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jiao</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;%s正在叫&#x27;</span>%<span class="hljs-keyword">self</span>.hidden_name)

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pao</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;%s正在跑&#x27;</span>%<span class="hljs-keyword">self</span>.hidden_name)

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">shui</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;%s正在睡觉&#x27;</span>%<span class="hljs-keyword">self</span>.hidden_name)

white = Dog(<span class="hljs-string">&#x27;小白&#x27;</span>,<span class="hljs-string">&#x27;1&#x27;</span>,<span class="hljs-string">&#x27;man&#x27;</span>)
white.jiao()

white.pao()

white.shui()


<span class="hljs-comment"># 这里是white这个对象在调用dog类中的方法，跑，叫，睡觉这些</span>

<span class="hljs-comment"># 这个是调用方法来修改white的属性，这个属性如果设置不可查看或者不可修改，可以把上面查看和修改的方法去掉</span>
print(<span class="hljs-string">&#x27;修改姓名前&#x27;</span>,white.get_name())
white.set_name(<span class="hljs-string">&#x27;小黑&#x27;</span>)
print(<span class="hljs-string">&#x27;修改姓名后&#x27;</span>,white.get_name())

<span class="hljs-comment"># 输出结果：</span>
	<span class="hljs-comment"># 修改姓名前 小白</span>
	<span class="hljs-comment"># 修改姓名后 小黑</span>

<span class="hljs-comment"># 属性被修改了</span></code></pre>

</li>
</ul>
<h2 id="类的一些补充"><a href="#类的一些补充" class="headerlink" title="类的一些补充"></a>类的一些补充</h2><ul>
<li><p>可以为对象的属性使用双下划线开头 __xxx</p>
</li>
<li><p>双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问</p>
</li>
<li><p>双下划线开头的是隐藏属性，隐藏属性只不过是python自动为属性改了一个名字</p>
</li>
<li><p>__属性名 实际上是将名字修改为了 <code>类名.__属性名</code></p>
<p>  这种的其实还是在外部可以改内部的属性值的</p>
</li>
</ul>
<h2 id="类中的装饰器"><a href="#类中的装饰器" class="headerlink" title="类中的装饰器"></a>类中的装饰器</h2><ul>
<li>property装饰器用来将一个方法，装换为对象的属性</li>
<li>添加property装饰器后，我们就可以像调用属性一样，调用方法</li>
<li>作用<blockquote>
<p>把方法变为属性，只可以用来访问</p>
</blockquote>
<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">student</span>():</span>

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name,age,score)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.name = name
        <span class="hljs-keyword">self</span>.age = age
        <span class="hljs-keyword">self</span>.score = score
    @property         <span class="hljs-comment"># 加入装饰器后</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.name
    @property          <span class="hljs-comment"># 加入装饰器后</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_age</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.age
    @property         <span class="hljs-comment"># 加入装饰器后 </span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_course</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> max(<span class="hljs-keyword">self</span>.score)
    
f1 = student(<span class="hljs-string">&#x27;kkk&#x27;</span>,<span class="hljs-number">17</span>,(<span class="hljs-number">100</span>,<span class="hljs-number">97</span>,<span class="hljs-number">98</span>))
f2 = student(<span class="hljs-string">&#x27;iii&#x27;</span>,<span class="hljs-number">11</span>,(<span class="hljs-number">70</span>,<span class="hljs-number">60</span>,<span class="hljs-number">10</span>))

print(f1.get_name)           <span class="hljs-comment"># 调用方法</span>
print(f1.get_age)            <span class="hljs-comment"># 调用方法             </span>
print(f1.get_course)

<span class="hljs-comment"># 加入装饰器后和调用属性差不多，就是调用方法的（）没了</span></code></pre>
<ul>
<li>setter装饰器</li>
<li> <code>@属性名.setter装饰器</code></li>
<li>作用<blockquote>
<p>把方法变为属性，对象可以直接赋值来修改</p>
</blockquote>
</li>
<li>这个装饰器是在property下一级的，没有property就不可以用这个装饰器</li>
<li>(这两个装饰器是一起用的，property的用来访问,setter的用来修改)<pre><code class="hljs ruby"><span class="hljs-comment"># 定义一个类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
	<span class="hljs-comment"># 初始化类的属性</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name
	<span class="hljs-comment"># 定义带有property装饰器的方法</span>
    @property
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>._name
	<span class="hljs-comment"># 定义带有 setter装饰器的方法 （这里的属性名是property装饰器下的方法，因为是修改get_name下的属性）</span>
    @get_name.setter
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">set_name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name

<span class="hljs-comment"># 创建一个类的实例 并给f1的name属性赋值  </span>
f1 = Person(<span class="hljs-string">&#x27;lmk&#x27;</span>)
<span class="hljs-comment"># 先打印看一下f1的属性值</span>
print(f1.get_name)
<span class="hljs-comment"># 结果是 lmk</span>

<span class="hljs-comment"># 修改 f1的name属性 （通过setter装饰器修改的）</span>
f1.set_name = <span class="hljs-string">&#x27;kml&#x27;</span>
<span class="hljs-comment"># 打印修改后的结果</span>
print(f1.get_name)
<span class="hljs-comment"># 结果是 kml</span>

<span class="hljs-comment"># 这样调用方法就好像调用属性一样，   </span>
		<span class="hljs-comment"># 但是setter这个装饰器</span>
		<span class="hljs-comment"># self._name = name	</span>
		<span class="hljs-comment"># name必须加上_让她变成隐藏的属性才能用，要不然会报错</span>
</code></pre>


</li>
</ul>
</li>
</ul>
<h2 id="继承"><a href="#继承" class="headerlink" title="继承"></a>继承</h2><ul>
<li><p>有一个类能够实现我们需要的大部分功能，但是不能实现全部功能</p>
</li>
<li><p>如何让这个类实现全部功能？</p>
<ol>
<li>直接修改这个类，在类中添加我们需要的功能，<br> 修改起来会比较麻烦，并且会违反ocp原则</li>
<li>直接创建一个新类，<br> 创建一个新类比较麻烦，并且会出现大量的复制粘贴，出现大量的重复代码</li>
<li>直接从一个类中来继承他的属性和方法</li>
</ol>
</li>
<li><p>继承是面向对象的三大特性之一</p>
</li>
<li><p>通过继承，我们可以使一个类获取到其他类中的属性和方法</p>
</li>
<li><p>在定义类时，可以在类名后的括号中指定当前类的父类，（超类，基类，super）</p>
</li>
<li><p>子类（衍生类）可以直接继承父类中的所有属性和方法</p>
</li>
<li><p>通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合ocp原则，    </p>
</li>
<li><p>所以我们经常需要通过继承来对一个类进行扩展</p>
<pre><code class="hljs python"><span class="hljs-comment">#定义一个父类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">lmk</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">run</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;动物会跑~~~&#x27;</span>)

	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">sleep</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;动物睡觉~~~&#x27;</span>)

<span class="hljs-comment"># 定义子类 继承父类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>(<span class="hljs-params">lmk</span>):</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">bark</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;www&#x27;</span>)

a = kml()

a.run() 
a.sleep()
a.bark()
<span class="hljs-comment"># 定义父类后，在用子类继承父类，父类的所有属性和方法，在子类都可以使用，并且在子类中还可以扩展方法，</span>
<span class="hljs-comment"># 在子类的方法，父类是不可以使用的</span>
		
<span class="hljs-comment"># 在创建子类时，如果省略不写父类，则默认父类为 object</span>
<span class="hljs-comment"># object是所有类的父类，所有类都继承字object</span></code></pre>
<blockquote>
<p>在创建子类时，如果省略不写父类，则默认父类为 object<br>object是所有类的父类，所有类都继承字object</p>
</blockquote>
</li>
</ul>
<ul>
<li><p>issubclass() 检查一个类是否是另一个类的子类</p>
<ul>
<li>参数， 1，子类 2，父类<pre><code class="hljs gauss"><span class="hljs-keyword">print</span>(<span class="hljs-built_in">issubclass</span>(kml,lmk))
<span class="hljs-meta"># 返回结果是 true</span></code></pre></li>
</ul>
</li>
<li><p>isinstance() 用来检查一个对象是否是一个类的实例</p>
<ul>
<li>参数，1，对象， 类<pre><code class="hljs python">print(<span class="hljs-built_in">isinstance</span>(a,lmk))
print(<span class="hljs-built_in">isinstance</span>(a,kml))
<span class="hljs-comment"># 这两个结果都是一样的</span>

<span class="hljs-comment"># 所有的对象都是object的实例</span>
<span class="hljs-comment"># print(isinstance(a,object))</span>
<span class="hljs-comment"># 返回true</span></code></pre>
<h2 id="继承-重写"><a href="#继承-重写" class="headerlink" title="继承-重写"></a>继承-重写</h2></li>
</ul>
</li>
<li><p>如果在子类中有和父类同名的方法，则，通过子类实例去调用方法时，</p>
</li>
<li><p>会调用子类的方法，而不是父类的方法，这个特点我们叫做方法的重写，（覆盖，override）</p>
<pre><code class="hljs python"><span class="hljs-comment">#定义一个父类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">lmk</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">run</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;动物会跑~~~&#x27;</span>)

	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">sleep</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;动物睡觉~~~&#x27;</span>)
<span class="hljs-comment"># 定义子类</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>(<span class="hljs-params">lmk</span>):</span>

	<span class="hljs-comment"># 在子类添加一个run方法</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">run</span>(<span class="hljs-params">self</span>):</span>
      	print(<span class="hljs-string">&#x27;动物会跳&#x27;</span>)

	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">bark</span>(<span class="hljs-params">self</span>):</span>
		print(<span class="hljs-string">&#x27;www&#x27;</span>)

a = kml()
<span class="hljs-comment"># 调用run方法</span>
print(a.run())
<span class="hljs-comment"># 输出结果   动物会跳</span>

<span class="hljs-comment"># 如果调用父类的方法，则输出结果还是动物会跑</span></code></pre></li>
<li><p>当我们调用一个对象的方法时，</p>
<ul>
<li>会优先去当前对象中寻找是否具有该方法，如果有则直接调用</li>
<li>如果没有，则去当前对象的父类中寻找，如果父类中有，则直接调用父类的方法，</li>
<li>如果父类没有，则去父类的父类中寻找，以此类推，直到找到object，如果依然没有找到，就报错</li>
</ul>
<blockquote>
<p>子类在调用方法是会优先在当前类中寻找有没有这个方法，没有就往上找</p>
</blockquote>
<h2 id="super"><a href="#super" class="headerlink" title="super()"></a>super()</h2></li>
<li><p>子类继承父类，父类的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法</p>
</li>
<li><p>super()可以获取当前类的父类</p>
</li>
<li><p>并且通过super()返回对象调用父类方法时，不需要传递self</p>
</li>
<li><p>格式:<br> <code>super().__init__(参数1,参数2)</code></p>
<pre><code class="hljs ruby"><span class="hljs-comment"># 定义一个父类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">hello</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name,age)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">self</span>._name = name
		<span class="hljs-keyword">self</span>._age = age
	@property
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>._name
	@name.setter
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">self</span>._name =  name

	@property
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">age</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>._age
	@name.setter
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,age)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">self</span>._age =  age

<span class="hljs-comment">#定义一个子类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>(<span class="hljs-title">hello</span>):</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name,age,hhh)</span></span><span class="hljs-symbol">:</span>
	    <span class="hljs-comment"># 通过super()函数接收父类的特殊方法，所以子类在创建对象时，把这个两个参数传递给父类(name,age)</span>
		<span class="hljs-keyword">super</span>().__init_<span class="hljs-number">_</span>(name,age) 
  		<span class="hljs-keyword">self</span>._hhh = hhh
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_hhh</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
		<span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.hhh

<span class="hljs-comment"># 创建子类的一个对象 </span>
a = kml(<span class="hljs-string">&#x27;kkk&#x27;</span>,<span class="hljs-number">18</span>,<span class="hljs-string">&#x27;hello&#x27;</span>)
<span class="hljs-comment"># kkk是父类的name 18是父类的age hello是子类的hhh</span>

print(a._name)
print(a._age)
print(a._hhh)</code></pre>

</li>
</ul>
<h2 id="多重继承"><a href="#多重继承" class="headerlink" title="多重继承"></a>多重继承</h2><ul>
<li>python是支持多重继承的，也就是我们可以为一个类同时指定多个父类</li>
<li>可以在类名（）后面添加多个类，实现多重继承</li>
<li>多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法</li>
<li>在开发中如果没有特殊的情况，应该尽量避免使用多重继承，因为多重继承会让我们的代码过于复杂</li>
</ul>
<ul>
<li><p>如果多个父类中有同名的方法，则会在第一个父类中寻找，然后找第二个一次类推</p>
</li>
<li><p>也就是父类中有同名的方法前面的父类会覆盖后面父类的同名方法</p>
</li>
<li><p><code>类名.__bases__</code></p>
</li>
<li><p>这个属性会获取当前类的所有父类</p>
<pre><code class="hljs clean">print(kml.__bases__)
# (&lt;<span class="hljs-keyword">class</span> <span class="hljs-string">&#x27;__main__.hello&#x27;</span>&gt;,)
# 父类的顺序是在继承括号中先写那个父类那个父类就是前面的父类</code></pre>

</li>
</ul>
<h2 id="多态"><a href="#多态" class="headerlink" title="多态"></a>多态</h2><ul>
<li><p>多态是面向对象的三大特性之一</p>
</li>
<li><p>多态从字面理解就是多种形态</p>
</li>
<li><p>就是一个对象可以以不同的形态去呈现</p>
<pre><code class="hljs ruby"><span class="hljs-comment"># 定义两个类</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name

    @property
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>._name
        
    @name.setter
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name   

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">B</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-number">10</span>            <span class="hljs-comment"># 通过len()来返回的值，return定什么值，len()函数就返回什么值</span>

    @property
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>._name
        
    @name.setter
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>._name = name   

<span class="hljs-comment"># 定义一个函数</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">say_hello</span><span class="hljs-params">(obj)</span></span><span class="hljs-symbol">:</span>
    print(<span class="hljs-string">&#x27;你好 %s&#x27;</span>%obj.name)

<span class="hljs-comment"># 对于这个函数来说只要对象中含有name属性，它就可以作为参数传递</span>
<span class="hljs-comment"># 这个函数不会考虑对象的类型，只要有name属性即可</span>

<span class="hljs-comment"># 再定义一个函数</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">say_hello_2</span><span class="hljs-params">(obj)</span></span><span class="hljs-symbol">:</span>
    <span class="hljs-comment"># 做类型检查</span>
    <span class="hljs-keyword">if</span> isinstance(obj , A)<span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;你好 %s&#x27;</span>%obj.name) 
<span class="hljs-comment"># 在这个函数中我们做了一个类型检查，也就是obj是A类型的对象时，才可以正常使用</span>
<span class="hljs-comment"># 其他类型的对象都无法使用该函数，这个函数就违反了多态</span>
<span class="hljs-comment"># 违反了多态的函数，只适用于一种类型的对象，无法处理其他类型的对象，这样导致函数的适应性非常差</span></code></pre></li>
<li><p>上面代码的len()</p>
<blockquote>
<p>之所以一个对象能通过len()来获取长度，是因为对象中具有一个特殊方法<strong>len</strong><br>换句话说，只要对象中具有__len__特殊方法，就可以通过len()来获取它的长度<br> 这个是输出类中定义对象的len</p>
</blockquote>
</li>
<li><p>如果打印对象的属性的话该多长还是多长</p>
<pre><code class="hljs lisp">print(<span class="hljs-name">len</span>(<span class="hljs-name">b</span>.name))</code></pre>

</li>
</ul>
<h2 id="类中的属性和方法"><a href="#类中的属性和方法" class="headerlink" title="类中的属性和方法"></a>类中的属性和方法</h2><ul>
<li>属性<ul>
<li>类属性      </li>
<li>实例属性</li>
</ul>
</li>
<li>方法<ul>
<li>类方法 </li>
<li>实例方法</li>
<li>静态方法</li>
</ul>
</li>
</ul>
<hr>
<ul>
<li><p>类属性，</p>
<blockquote>
<p>直接在类中定义的属性</p>
</blockquote>
<ul>
<li>类属性可以通过类或类的实例对象访问到</li>
<li>但是类属性只能通过类本身修改，无法通过实例对象修改，实例对象只能是覆盖类的属性，就是给实例对象重新赋值</li>
</ul>
</li>
<li><p>实例属性</p>
<blockquote>
<p>通过实例对象添加的属性属于实例属性</p>
</blockquote>
<ul>
<li>实例属性只能通过实例对象修改和访问，类对象无法修改</li>
<li>__init__方法是定义实例属性的位置<pre><code class="hljs python">例如
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>:</span>
   <span class="hljs-keyword">pass</span>

a = kml()	
a.age = <span class="hljs-number">19</span>   <span class="hljs-comment"># 这就是实例属性</span></code></pre>




</li>
</ul>
</li>
</ul>
<ul>
<li><p>实例方法，</p>
<blockquote>
<p>在类中定义，以self为第一个参数的方法都是实例方法</p>
</blockquote>
<ul>
<li><p>实例方法在调用时，python会将调用对象作为self传入</p>
</li>
<li><p>实例方法可以通过实例和类去调用</p>
</li>
<li><p>当通过实例去调用时会自动将当前调用对象作为self传入</p>
</li>
<li><p>当通过类去调用时，不会自动传递self，此时我们必须手动传递self</p>
<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
       	print(<span class="hljs-string">&#x27;这是test方法~~~ &#x27;</span> , <span class="hljs-keyword">self</span>)

a = kml()
a.tset() <span class="hljs-comment"># 通过实例对象调用</span>
kml.test(a) <span class="hljs-comment"># 通过类调用  必须传入一个实例对象</span>

<span class="hljs-comment"># a.test() 和 kml.test(a) 是相等的</span>
<span class="hljs-comment"># 一个是通过实例来调用方法 ，解释器默认传入调用的对象</span>
<span class="hljs-comment"># 一个是通过类来调用方法并把实例参数传入</span>
</code></pre></li>
</ul>
</li>
<li><p>类方法</p>
<blockquote>
<p>在类内部使用@classmethod来修饰的方法属于类方法</p>
</blockquote>
<ul>
<li>类方法的第一个参数是cls 也会被自动传递，cls就是当前类对象</li>
<li>类方法和实例方法的区别，实例方法的第一个参数是self，而类方法的第一个参数是cls</li>
<li>类方法可以通过类去调用，也可以通过实例去调用，没有区别<pre><code class="hljs python"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>:</span>
<span class="hljs-meta">	@classmethod</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lei</span>(<span class="hljs-params">cls</span>):</span>
		print(<span class="hljs-string">&#x27;这是类方法&#x27;</span>)
kml.lei()
a.lei()
<span class="hljs-comment"># 类和对象都可以进行调用</span></code></pre></li>
</ul>
</li>
<li><p>静态方法</p>
<blockquote>
<p>在类中使用@staticmethod来修饰的方法数据静态方法</p>
</blockquote>
<ul>
<li><p>静态方法不需要指定任何的默认参数</p>
</li>
<li><p>静态方法可以通过类和实例去调用</p>
<blockquote>
<p>静态方法，基本上就是一个和当前类无关的方法，他只是一个保存到当期类中的函数</p>
</blockquote>
</li>
<li><p>静态方法一般都是一些工具方法，和当前类无关</p>
<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">kml</span>:</span>
	@staticmethod
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jing_tai</span><span class="hljs-params">()</span></span><span class="hljs-symbol">:</span>
		print(<span class="hljs-string">&#x27;这是一个静态方法&#x27;</span>)
			
kml.jing_tai()
a.jing_tai()
<span class="hljs-comment"># 类和对象都可以调用 并且不用传递任何参数 （没有self 没有 cls）</span></code></pre>


</li>
</ul>
</li>
</ul>
<h2 id="垃圾回收"><a href="#垃圾回收" class="headerlink" title="垃圾回收"></a>垃圾回收</h2><ul>
<li><p>程序在运行过程中会产生垃圾</p>
</li>
<li><p>并且会影响程序运行的运行性能，所以这些垃圾必须被清理</p>
</li>
<li><p>在程序中没有被引用的对象就是垃圾，所谓垃圾回收就是将垃圾对象从内存中删除</p>
</li>
<li><p>在python中有自动的垃圾回收机制，它会自动将这些没有被引用的对象删除</p>
</li>
<li><p>所以我们不用手动处理垃圾回收</p>
<blockquote>
<p>python的垃圾回收机制</p>
</blockquote>
<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.name = <span class="hljs-string">&#x27;A类&#x27;</span>

    <span class="hljs-comment"># del是一个特殊方法，它会在对象被垃圾回收前调用</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__del__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        print(<span class="hljs-string">&#x27;A()对象被删除了~~~&#x27;</span>,<span class="hljs-keyword">self</span>)

a = A()
b = a       <span class="hljs-comment"># 又使用一个变量b，来引用a对应的对象</span>

print(a.name)
input(<span class="hljs-string">&#x27;回车键退出...&#x27;</span>)

<span class="hljs-comment"># 回车后python才会进行垃圾回收 在a回收之前会执行 __del__这个特殊方法</span>
<span class="hljs-comment"># 输出结果 A类</span>
		<span class="hljs-comment"># A()对象被删除了~~~</span></code></pre>
<pre><code class="hljs python"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self</span>):</span>
        self.name = <span class="hljs-string">&#x27;A类&#x27;</span>

    <span class="hljs-comment"># del是一个特殊方法，它会在对象被垃圾回收前调用</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__del__</span>(<span class="hljs-params">self</span>):</span>
        print(<span class="hljs-string">&#x27;A()对象被删除了~~~&#x27;</span>,self)

a = A()
b = a       <span class="hljs-comment"># 又使用一个变量b，来引用a对应的对象</span>

print(a.name)

a = <span class="hljs-literal">None</span> <span class="hljs-comment"># 将a设置为了None，此时没有任何的变量对A()对象进行引用，它就是变成了垃圾</span>
b = <span class="hljs-literal">None</span>
<span class="hljs-comment"># del a</span>
<span class="hljs-comment"># del b</span>
<span class="hljs-built_in">input</span>(<span class="hljs-string">&#x27;回车键退出...&#x27;</span>)
<span class="hljs-comment"># 结果是 程序还在 input阻塞 A类就被垃圾回收了</span>

<span class="hljs-comment"># 这个实例是 在回车之前A类就被删除了 因为 我们将a这个实例对象设置为了 None</span>
<span class="hljs-comment"># 这里注释的 del a  del b 和 把对象改为 None的效果是一样的</span></code></pre>
<h2 id="类中垃圾回收的特殊方法"><a href="#类中垃圾回收的特殊方法" class="headerlink" title="类中垃圾回收的特殊方法"></a>类中垃圾回收的特殊方法</h2><ul>
<li><p>del这个特殊方法，会在对象被垃圾回收前调用</p>
<ul>
<li>调用后，这个空着的对象就会被删除</li>
</ul>
</li>
<li><p>怎么分辨这个对象是不是垃圾呢</p>
<ul>
<li>如果这个对象有变量去调用它就不是，如果这个变量在后面有重新赋值了，有没有其他变量来引用这个对象，那么就是垃圾</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="类中的所有特殊方法"><a href="#类中的所有特殊方法" class="headerlink" title="类中的所有特殊方法"></a>类中的所有特殊方法</h2><ul>
<li><p>特殊方法都是使用__开头和结尾的</p>
</li>
<li><p>特殊方法一般不需要我们手动调用，需要在一些特殊情况下执行</p>
</li>
<li><p><strong>str</strong><br><code>__str__(self)</code> </p>
<ul>
<li>这个特殊方法会在尝试将对象转换为字符串的时候调用</li>
<li>它的作用可以用来指定对象转换为，字符串的结果</li>
<li>比如print(a)  a是实例对象</li>
<li>如果不定义<strong>str</strong> 只会返回父类名称和内存地址</li>
<li>定义了以后会返回你所指定的对象(字符串)<pre><code class="hljs angelscript"><span class="hljs-keyword">class</span> <span class="hljs-symbol">A:</span>
    <span class="hljs-symbol">def</span> <span class="hljs-symbol">__str__</span>(<span class="hljs-symbol">self</span>):
        <span class="hljs-symbol">return</span> &#x27;这是一个<span class="hljs-symbol">A</span>类&#x27;

<span class="hljs-symbol">a</span> = <span class="hljs-symbol">A</span>()
<span class="hljs-symbol">print</span>(<span class="hljs-symbol">a</span>)
# 打印结果
    # 这是一个<span class="hljs-symbol">A</span>类</code></pre>
</li>
</ul>
</li>
<li><p><strong>repr</strong><br> <code>__repr__(self)</code> </p>
<ul>
<li>这个方法会在对当前使用repr()函数时调用</li>
<li>它的作用是指定对象在交互界面直接输出结果<pre><code class="hljs angelscript"><span class="hljs-keyword">class</span> <span class="hljs-symbol">A:</span>
    <span class="hljs-symbol">def</span> <span class="hljs-symbol">__repr__</span>(<span class="hljs-symbol">self</span>):
        <span class="hljs-symbol">return</span> &#x27;你使用了<span class="hljs-symbol">repr</span>()函数&#x27;

<span class="hljs-symbol">a</span> = <span class="hljs-symbol">A</span>()
<span class="hljs-symbol">print</span>(<span class="hljs-symbol">repr</span>(<span class="hljs-symbol">a</span>))
# 打印结果
   # 你使用了<span class="hljs-symbol">repr</span>()函数</code></pre>
</li>
</ul>
</li>
<li><p>str 和 repr<br> <code>__str__ and __repr__这两个方法都是用于显示的， str是面向用户的 而repr是面向开发人员的</code></p>
</li>
<li><p>打印类的时候默认是将类转换为str形式</p>
</li>
<li><p>new<br> <strong>new</strong>(self)</p>
<ul>
<li>是在新式类中出现的方法，就是用来创建对象的 ，一般不用这个变量 </li>
</ul>
</li>
<li><p>运算方法</p>
<pre><code class="hljs reasonml"># <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__add__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 加
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__sub__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 减
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__mul__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span>  乘法
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__matmul__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> @
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__truediv__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span>  /
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__floordiv__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> <span class="hljs-comment">//</span>
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__mod__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span>     %
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__divmod__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> divmod, divmod(a, b) = (a/b, a%b)
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__pow__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>[, <span class="hljs-params">modulo</span>])</span>  **
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__lshift__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> &lt;&lt;
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__rshift__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> &gt;&gt;
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__and__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span>  &amp;
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__xor__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> ^
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__or__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> <span class="hljs-pattern-match">|</span></code></pre></li>
<li><p>比较方法</p>
<pre><code class="hljs reasonml"># <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__lt__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 小于 &lt;
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__le__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 小于等于 &lt;=
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__eq__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 等于 ==
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__ne__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 不等于 !=
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__gt__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 大于 &gt;
# <span class="hljs-keyword">object</span>.<span class="hljs-constructor">__ge__(<span class="hljs-params">self</span>, <span class="hljs-params">other</span>)</span> 大于等于 &gt;=</code></pre>
</li>
<li><p>举例__gt__这个方法</p>
<ul>
<li><p>gt会在对象做大于比较时调用，该方法的返回值将会作为比较的结果</p>
</li>
<li><p>需要两个参数，一个self表示当前对象，other表示和当前对象比较的对象</p>
</li>
<li><p>也就是 如果是大于的话 就返回前面得参数就大于后面的参数</p>
<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name,age)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.name = name
        <span class="hljs-keyword">self</span>.age = age

    <span class="hljs-comment"># 定义gt方法  </span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__gt__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,other)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-comment"># 如果 self 大于 other 返回true 否则返回 false</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.age &gt; other.age   <span class="hljs-comment"># 这里如果写小于的话 就直接返回false 因为 是否大于</span>

		<span class="hljs-comment"># 在啰嗦一遍，创建一个gt方法，如果前面的age&gt;后面的age则就返回true反之就反之就返回false</span>

<span class="hljs-comment"># 创建实例对象</span>
a = A(<span class="hljs-string">&#x27;lmk&#x27;</span>,<span class="hljs-number">18</span>)
b = A(<span class="hljs-string">&#x27;kml&#x27;</span>,<span class="hljs-number">16</span>)

<span class="hljs-comment"># 这里调用gt方法，传入要比较的对象</span>
print(a.__gt_<span class="hljs-number">_</span>(b))


<span class="hljs-comment"># 输出结果是 true </span>
</code></pre>


</li>
</ul>
</li>
</ul>
<ul>
<li><p>__len__是获取长度的函数</p>
<ul>
<li>在类中定义__len__方法，在这个方法内写什么，print(len(对象名或者类名)) 就是什么，因为不是打印的属性<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,name)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.name = name
	<span class="hljs-comment"># 定义 len方法</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-number">10</span>  <span class="hljs-comment"># 直接返回10 </span>


a = A(<span class="hljs-string">&#x27;lmk&#x27;</span>)
<span class="hljs-comment"># a对象调用 len方法 就直接返回 上面定义的10</span>
print(a.__len_<span class="hljs-number">_</span>())
</code></pre>
</li>
</ul>
</li>
<li><p>__bool__可以通过bool来指定对象转换为布尔值的情况</p>
<ul>
<li>这个方法可以指定这个类返回的bool值是true还是false<pre><code class="hljs ruby"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>,age)</span></span><span class="hljs-symbol">:</span>
        <span class="hljs-keyword">self</span>.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__bool__</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span><span class="hljs-symbol">:</span>
	<span class="hljs-comment"># 可以用来指定条件，如果 *** 大于 一个数字，则返回true，反之就返回false</span>
  	    <span class="hljs-keyword">return</span> <span class="hljs-keyword">self</span>.age &gt; <span class="hljs-number">17</span>	


a = A(<span class="hljs-number">18</span>)

print(a.__bool_<span class="hljs-number">_</span>())
<span class="hljs-comment"># 这里 a对象传入了18 大于 类中的17 所以 返回结果是 true 如果小于就返回 false</span></code></pre>



</li>
</ul>
</li>
</ul>
<blockquote>
<p>这些特殊方法可以配合多态进行使用<br><a target="_blank" rel="noopener" href="https://www.jianshu.com/p/882492a9fa99">https://www.jianshu.com/p/882492a9fa99</a>    python 类的运算方法博客可以参考</p>
</blockquote>

            </div>
            <hr>
            <div>
              <div class="post-metas mb-3">
                
                  <div class="post-meta mr-3">
                    <i class="iconfont icon-category"></i>
                    
                      <a class="hover-with-bg" href="/categories/python/">python</a>
                    
                  </div>
                
                
                  <div class="post-meta">
                    <i class="iconfont icon-tags"></i>
                    
                      <a class="hover-with-bg" href="/tags/python%E5%9F%BA%E7%A1%80/">python基础</a>
                    
                  </div>
                
              </div>
              
                <p class="note note-warning">本博客所有文章是以学习为目的，如果有不对的地方可以一起交流沟通共同学习 邮箱:1248287831@qq.com！</p>
              
              
                <div class="post-prevnext row">
                  <article class="post-prev col-6">
                    
                    
                      <a href="/2020/09/01/python-python%E6%A8%A1%E5%9D%97%EF%BC%88os%E4%BB%A5%E5%8F%8Asys%EF%BC%89-%E6%A0%87%E5%87%86%E5%BA%93%E4%BB%A5%E5%8F%8A%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86/">
                        <i class="iconfont icon-arrowleft"></i>
                        <span class="hidden-mobile">python模块（os以及sys）-标准库以及异常处理</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </article>
                  <article class="post-next col-6">
                    
                    
                      <a href="/2020/08/20/python-%E7%B1%BB(class)/">
                        <span class="hidden-mobile">python类(class)</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="iconfont icon-arrowright"></i>
                      </a>
                    
                  </article>
                </div>
              
            </div>

            
          </article>
        </div>
      </div>
    </div>
    
      <div class="d-none d-lg-block col-lg-2 toc-container" id="toc-ctn">
        <div id="toc">
  <p class="toc-header"><i class="iconfont icon-list"></i>&nbsp;目录</p>
  <div id="tocbot"></div>
</div>

      </div>
    
  </div>
</div>

<!-- Custom -->


    
  </main>

  
    <a id="scroll-top-button" href="#" role="button">
      <i class="iconfont icon-arrowup" aria-hidden="true"></i>
    </a>
  

  
    <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v"
                 for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>
  

  

  <footer class="text-center mt-5 py-3">
  <div class="footer-content">
     <a href="https://space.bilibili.com/39165374" target="_blank" rel="nofollow noopener"><span>LMK</span></a> <i class="iconfont icon-love"></i> <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"><span>Fluid</span></a> 
  </div>
  
  <div class="statistics">
    
    

    
      
        <!-- 不蒜子统计PV -->
        <span id="busuanzi_container_site_pv" style="display: none">
            总访问量 
            <span id="busuanzi_value_site_pv"></span>
             次
          </span>
      
      
        <!-- 不蒜子统计UV -->
        <span id="busuanzi_container_site_uv" style="display: none">
            总访客数 
            <span id="busuanzi_value_site_uv"></span>
             人
          </span>
      
    
  </div>


  

  
</footer>

<!-- SCRIPTS -->
<script  src="https://cdn.staticfile.org/jquery/3.4.1/jquery.min.js" ></script>
<script  src="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/js/bootstrap.min.js" ></script>
<script  src="/js/debouncer.js" ></script>
<script  src="/js/main.js" ></script>

<!-- Plugins -->


  
    <script  src="/js/lazyload.js" ></script>
  



  



  <script defer src="https://cdn.staticfile.org/clipboard.js/2.0.6/clipboard.min.js" ></script>
  <script  src="/js/clipboard-use.js" ></script>



  <script defer src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js" ></script>





  <script  src="https://cdn.staticfile.org/tocbot/4.11.1/tocbot.min.js" ></script>
  <script>
    $(document).ready(function () {
      var boardCtn = $('#board-ctn');
      var boardTop = boardCtn.offset().top;

      tocbot.init({
        tocSelector: '#tocbot',
        contentSelector: '#post-body',
        headingSelector: 'h1,h2,h3,h4,h5,h6',
        linkClass: 'tocbot-link',
        activeLinkClass: 'tocbot-active-link',
        listClass: 'tocbot-list',
        isCollapsedClass: 'tocbot-is-collapsed',
        collapsibleClass: 'tocbot-is-collapsible',
        collapseDepth: 0,
        scrollSmooth: true,
        headingsOffset: -boardTop
      });
      if ($('.toc-list-item').length > 0) {
        $('#toc').css('visibility', 'visible');
      }
    });
  </script>



  <script  src="https://cdn.staticfile.org/typed.js/2.0.11/typed.min.js" ></script>
  <script>
    var typed = new Typed('#subtitle', {
      strings: [
        '  ',
        "python类(class)-面向对象&nbsp;",
      ],
      cursorChar: "_",
      typeSpeed: 70,
      loop: false,
    });
    typed.stop();
    $(document).ready(function () {
      $(".typed-cursor").addClass("h2");
      typed.start();
    });
  </script>



  <script  src="https://cdn.staticfile.org/anchor-js/4.2.2/anchor.min.js" ></script>
  <script>
    anchors.options = {
      placement: "right",
      visible: "hover",
      
    };
    var el = "h1,h2,h3,h4,h5,h6".split(",");
    var res = [];
    for (item of el) {
      res.push(".markdown-body > " + item)
    }
    anchors.add(res.join(", "))
  </script>



  <script  src="/js/local-search.js" ></script>
  <script>
    var path = "/local-search.xml";
    var inputArea = document.querySelector("#local-search-input");
    inputArea.onclick = function () {
      searchFunc(path, 'local-search-input', 'local-search-result');
      this.onclick = null
    }
  </script>



  <script  src="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.js" ></script>
  <link  rel="stylesheet" href="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.css" />

  <script>
    $('#post img:not(.no-zoom img, img[no-zoom]), img[zoom]').each(
      function () {
        var element = document.createElement('a');
        $(element).attr('data-fancybox', 'images');
        $(element).attr('href', $(this).attr('src'));
        $(this).wrap(element);
      }
    );
  </script>















</body>
</html>
